import 'dart:io';
import 'dart:typed_data';

import 'package:shared_preferences/shared_preferences.dart';
import 'package:tdesign_flutter/tdesign_flutter.dart';

class SocketModbusTcp {
  static Future<void> loadPreferences() async {
    try {
      final prefs = await SharedPreferences.getInstance();

      // 读取数据并提供默认值
      final address = prefs.getString('address');
      final port = prefs.getInt('port');
      final line = prefs.getString('line');
      ;

      if (address == null) {
        prefs.setString("address", "192.168.5.90");
      }
      if (port == null) {
        prefs.setString("port", "5005");
      }
      if (line == null) {
        // 家用 商用
        prefs.setString("line", "2");
      }

      // 在这里可以使用这些值初始化你的状态
      // 例如: setState(() { _address = address; });
    } catch (e) {
      print('Error loading preferences: $e');
      // 处理错误情况，可能设置默认值
    }
  }

  /// 读取 Modbus 寄存器并支持 Float32 解析
  /// [ip]: Modbus TCP 服务器 IP
  /// [port]: 端口（默认502）
  /// [startAddr]: 起始寄存器地址（如 0 对应 40001）
  /// [count]: 要读取的寄存器数量（Float32 需为偶数）
  /// [returnFloat]: 是否返回 Float32 值（默认 false，返回原始寄存器值）
  static Future<dynamic> readModbusRegisters(
      String ip,
      int port,
      int startAddr,
      int count, {
        bool returnFloat = false,
      }) async {
    final socket = await Socket.connect(ip, port);
    final transactionId = 0x0001; // 事务 ID（可随机生成）
    final protocolId = 0x0000;    // Modbus TCP 固定为 0
    final unitId = 0x01;          // 设备 ID（通常为 1）

    // 构造 Modbus TCP 请求帧（功能码 0x03：读保持寄存器）
    final request = Uint8List(12);
    ByteData.view(request.buffer)
      ..setUint16(0, transactionId, Endian.big)  // 事务 ID
      ..setUint16(2, protocolId, Endian.big)     // 协议 ID
      ..setUint16(4, 6, Endian.big)              // 剩余字节数
      ..setUint8(6, unitId)                      // 单元 ID
      ..setUint8(7, 0x03)                        // 功能码
      ..setUint16(8, startAddr, Endian.big)      // 起始地址
      ..setUint16(10, count, Endian.big);        // 寄存器数量

    socket.add(request);
    await socket.flush();

    // 接收响应
    final response = await socket.first;
    socket.close();

    // 解析响应
    if (response.length < 9 + count * 2) {
      throw Exception('响应数据长度不足');
    }

    // 提取寄存器数据（跳过前9字节的Modbus TCP头）
    final data = Uint8List.sublistView(response, 9);

    if (returnFloat) {
      if (count % 2 != 0) {
        // TDToast.showFail("读取Float32需要偶数个寄存器", context: context)
        return;
      }
      // 转换为Float32列表
      return _parseFloat32FromRegisters(data, count ~/ 2);
    } else {
      // 返回原始寄存器值（16位整数列表）
      return _parseRegisters(data, count);
    }
  }

  /// 解析原始寄存器值（16位整数列表）
  static List<int> _parseRegisters(Uint8List data, int count) {
    return List<int>.generate(count, (i) {
      final offset = i * 2;
      return (data[offset] << 8) | data[offset + 1]; // 大端序
    });
  }

  /// 解析Float32值（每2个寄存器转1个Float）
  static List<double> _parseFloat32FromRegisters(Uint8List data, int floatCount) {
    final floats = <double>[];
    final byteData = ByteData.sublistView(data);

    for (int i = 0; i < floatCount; i++) {
      final offset = i * 4;
      // 注意字节序（Modbus通常为大端序）
      final floatValue = byteData.getFloat32(offset, Endian.big);
      floats.add(floatValue);
    }

    return floats;
  }

}